package printnum;

import java.text.SimpleDateFormat;
import java.util.Date;

public class PrintNum {
    private static final short MAX_NUM = 75;
    private static final SimpleDateFormat DF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private volatile short num = 0;
    private volatile boolean firstCondiction = true;
    private volatile boolean secondCondiction = false;
    private volatile boolean thirdCondiction = false;

    private synchronized void printNum(short threadIndex) throws InterruptedException {
        //循环执行，直到满足条件
        while (num <= MAX_NUM) {
            // synchronized 只有一个任务队列
            // 唤醒所有线程，获取锁的不一定是期望的线程，有点类似"活锁"，一直是其他两个线程获取到锁，但又不满足条件
            // 因此等待到期望的线程需要运气
            // 此处可能不阻塞，可能阻塞很久
            if ((firstCondiction && threadIndex == 1)
                    || (secondCondiction && threadIndex == 2)
                    || (thirdCondiction && threadIndex == 3)) {
                for (int i = 1; i <= 5; i++) {
                    num++;
                    if (num <= MAX_NUM) {
                        //特意加了时间来说明等待时间长短
                        System.out.println(DF.format(new Date()) + " 线程" + threadIndex + ":" + num);
                    }
                }
                // 按照1->2->3->1的顺序指定条件
                switch (threadIndex) {
                    case 1:
                        firstCondiction = false;
                        secondCondiction = true;
                        thirdCondiction = false;
                        break;
                    case 2:
                        firstCondiction = false;
                        secondCondiction = false;
                        thirdCondiction = true;
                        break;
                    case 3:
                        firstCondiction = true;
                        thirdCondiction = false;
                        secondCondiction = false;
                        break;
                    default:
                        System.out.println("errorIndex:" + threadIndex);
                        break;
                }
            }
            // 唤醒所有线程，线程重新获取锁
            notifyAll();
            //当前线程等待其他线程唤醒
            wait(100);
        }
        wait(100);
    }

    private void printAllNum() {
        //生成3个线程
        for (short i = 1; i <= 3; i++) {
            final short threadIndex = i;
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    try {
                        printNum(threadIndex);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },
                    "线程" + i);
            thread.start();
        }
    }

    public static void main(String[] args) {
        PrintNum printNum = new PrintNum();
        printNum.printAllNum();
    }
}

package printnum;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionPrintNum {
    private static final short MAX_NUM = 75;
    private static final SimpleDateFormat DF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private final Lock lock = new ReentrantLock();
    private final Condition condition1 = lock.newCondition();
    private final Condition condition2 = lock.newCondition();
    private final Condition condition3 = lock.newCondition();
    private AtomicInteger num = new AtomicInteger(0);
    private volatile short lastThreadIndex = 3;

    //可以指定唤醒哪个队列的线程（signalCondition）
    private void printNum(Condition currentCondition, Condition signalCondition, short threadIndex)
            throws InterruptedException {
        while (num.intValue() <= MAX_NUM) {
            // 判断准入条件，直到满足
            while ((lastThreadIndex == 3 && threadIndex != 1)
                    || (lastThreadIndex == 1 && threadIndex != 2)
                    || (lastThreadIndex == 2 && threadIndex != 3)) {
                signalCondition.signalAll();
                currentCondition.await(100, TimeUnit.MILLISECONDS);
            }
            for (int i = 1; i <= 5; i++) {
                num.getAndAdd(1);
                if (num.intValue() <= MAX_NUM) {
                    //特意加了时间来说明等待时间长短
                    System.out.println(DF.format(new Date()) + " 线程" + threadIndex + ":" + num);
                }
            }
            lastThreadIndex = threadIndex;
            signalCondition.signalAll();
            currentCondition.await(100, TimeUnit.MILLISECONDS);
        }
        currentCondition.await(100, TimeUnit.MILLISECONDS);
    }

    private void printAllNum() {
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                try {
                    lock.lock();
                    // 指定线程1完成后唤醒condition2线程，同时进入condition1排队
                    printNum(condition1, condition2, (short) 1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    condition3.signal();
                    lock.unlock();
                }
            }
        },
                "线程1");
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                try {
                    lock.lock();
                    // 指定线程2完成后唤醒condition3线程，同时进入condition2排队
                    printNum(condition2, condition3, (short) 2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    condition1.signal();
                    lock.unlock();
                }
            }
        },
                "线程2");
        Thread thread3 = new Thread(new Runnable() {
            public void run() {
                try {
                    lock.lock();
                    // 指定线程3完成后唤醒condition1线程，同时进入condition3排队
                    printNum(condition3, condition1, (short) 3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    condition2.signal();
                    lock.unlock();
                }
            }
        },
                "线程3");
        thread1.start();
        thread2.start();
        thread3.start();
    }

    public static void main(String[] args) {
        ConditionPrintNum printNum = new ConditionPrintNum();
        printNum.printAllNum();
    }
}